package com.paranoid.flashcard.dao;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.channels.FileChannel;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Environment;
import android.util.Log;

import com.paranoid.flashcard.model.Card;
import com.paranoid.flashcard.model.Deck;

public class FlashcardDatabase extends SQLiteOpenHelper {
    private final static String DATABASE_NAME = "paranoid.flascard";
    private static String DB_PATH = "/data/data/com.paranoid.flashcard/databases/";
    private Context mContext;
    File dbFile;
    private final static int DATABASE_VERSION = 2;
    private final static String CARD_TABLE_CREATE = "CREATE TABLE " + Card.TABLE_NAME + " (" + Card.KEY_ID
            + " INTEGER PRIMARY KEY AUTOINCREMENT, " + Card.KEY_TERM + " TEXT, " + Card.KEY_DEFINITION + " TEXT, "
            + Card.KEY_DECK + " INTEGER, "
            + Card.KEY_MASTERY + " INTEGER) ";


    
    public FlashcardDatabase(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        mContext = context;
        File dbFile = context.getDatabasePath(DATABASE_NAME);
        Log.i("", "PATH = " + dbFile.toString());
//        context.deleteDatabase(DATABASE_NAME);
//        saveDatabaseToSd();
//        try {
//            this.createDataBase();
//        } catch (IOException ex) { 
//            Log.e("", "Can't initialize database");
//        }
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        Log.i("", "recreating");
        db.execSQL(Deck.DECK_TABLE_CREATE);
        db.execSQL(CARD_TABLE_CREATE);
    }

    public static void saveDatabaseToSd() {
        try {
            File sd = Environment.getExternalStorageDirectory();
            File data = Environment.getDataDirectory();
            if (sd.canWrite()) {
                String currentDBPath = "/data/com.paranoid.flashcard/databases/paranoid.flascard";
                String backupDBPath = "/bb/paranoid.flascard";
                File currentDB = new File(data, currentDBPath);
                File backupDB = new File(sd, backupDBPath);
                if (currentDB.exists()) {
                    FileChannel src = new FileInputStream(currentDB).getChannel();
                    FileChannel dst = new FileOutputStream(backupDB).getChannel();
                    dst.transferFrom(src, 0, src.size());
                    src.close();
                    dst.close();
                } else {
                    Log.i("", "NOOOOOOOOOOOOOOOOOOOOOOOOOOOO");
                }
            } else {
                Log.i("", "NOOOWRITEEEE");
            }
        } catch (Exception e) {
            Log.i("", "Error", e);
        }
    }


    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }

    private void makeLogsFolder() {
        try {
            File sdFolder = new File(Environment.getExternalStorageDirectory(), "/bb/");
            sdFolder.mkdirs();
        } catch (Exception e) {
        }
    }

    /**
     * Creates a empty database on the system and rewrites it with your own
     * database.
     * */
    public void createDataBase() throws IOException {
        boolean dbExist = checkDataBase();

        if (dbExist) {
            // do nothing - database already exist
        } else {
            // By calling this method and empty database will be created into
            // the default system path
            // of your application so we are gonna be able to overwrite that
            // database with our database.
            this.getReadableDatabase();
            try {
                copyDataBase();
            } catch (IOException e) {
                throw new Error("Error copying database");
            }
        }
    }

    /**
     * Check if the database already exist to avoid re-copying the file each
     * time you open the application.
     * @return true if it exists, false if it doesn't
     */
    private boolean checkDataBase() {
        SQLiteDatabase checkDB = null;

        try {
            String myPath = DB_PATH + DATABASE_NAME;
            checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
        } catch (SQLiteException e) {
            // database does't exist yet.
        }
        if (checkDB != null) {
            checkDB.close();
        }

        return checkDB != null ? true : false;
    }

    /**
     * Copies your database from your local assets-folder to the just created
     * empty database in the system folder, from where it can be accessed and
     * handled. This is done by transfering bytestream.
     * */
    private void copyDataBase() throws IOException {
        // Open your local db as the input stream
        InputStream myInput = mContext.getAssets().open(DATABASE_NAME);

        // Path to the just created empty db
        String outFileName = DB_PATH + DATABASE_NAME;

        // Open the empty db as the output stream
        OutputStream myOutput = new FileOutputStream(outFileName);

        // transfer bytes from the inputfile to the outputfile
        byte[] buffer = new byte[1024];
        int length;
        while ((length = myInput.read(buffer)) > 0) {
            myOutput.write(buffer, 0, length);
        }
        // Close the streams
        myOutput.flush();
        myOutput.close();
        myInput.close();
    }

}
